Termination w.r.t. Q proof of TRS/Cimebig.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> EQ₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(y, z)
LOG'₁(1₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(app₂(l1, l2)) -> PROD₁(l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
SUM₁(app₂(l1, l2)) -> +¹₂(sum₁(l1), sum₁(l2))
INTER₂(l1, cons₂(x, l2)) -> MEM₂(x, l1)
LOG'₁(0₁(x)) -> LOG'₁(x)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> 0¹₁(+₂(+₂(x, y), 1₁(#)))
-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)
*¹₂(1₁(x), y) -> 0¹₁(*₂(x, y))
*¹₂(1₁(x), y) -> +¹₂(0₁(*₂(x, y)), y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)
APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)
MEM₂(x, cons₂(y, l)) -> IF₃(eq₂(x, y), true, mem₂(x, l))
LOG'₁(0₁(x)) -> GE₂(x, 1₁(#))
SUM₁(app₂(l1, l2)) -> SUM₁(l1)
GE₂(0₁(x), 1₁(y)) -> NOT₁(ge₂(y, x))
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
LOG'₁(0₁(x)) -> +¹₂(log'₁(x), 1₁(#))
PROD₁(cons₂(x, l)) -> *¹₂(x, prod₁(l))
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(0₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))
SUM₁(nil) -> 0¹₁(#)
EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
-¹₂(1₁(x), 1₁(y)) -> 0¹₁(-₂(x, y))
EQ₂(0₁(x), #) -> EQ₂(x, #)
EQ₂(#, 0₁(y)) -> EQ₂(#, y)
+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> 0¹₁(-₂(x, y))
LOG₁(x) -> LOG'₁(x)
INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
*¹₂(x, +₂(y, z)) -> +¹₂(*₂(x, y), *₂(x, z))
*¹₂(1₁(x), y) -> *¹₂(x, y)
+¹₂(0₁(x), 0₁(y)) -> 0¹₁(+₂(x, y))
MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)
LOG'₁(1₁(x)) -> LOG'₁(x)
SUM₁(cons₂(x, l)) -> +¹₂(x, sum₁(l))
LOG₁(x) -> -¹₂(log'₁(x), 1₁(#))
GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
INTER₂(l1, app₂(l2, l3)) -> APP₂(inter₂(l1, l2), inter₂(l1, l3))
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
SUM₁(cons₂(x, l)) -> SUM₁(l)
LOG'₁(0₁(x)) -> IF₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
GE₂(#, 0₁(x)) -> GE₂(#, x)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
PROD₁(app₂(l1, l2)) -> *¹₂(prod₁(l1), prod₁(l2))
INTER₂(app₂(l1, l2), l3) -> APP₂(inter₂(l1, l3), inter₂(l2, l3))
*¹₂(0₁(x), y) -> 0¹₁(*₂(x, y))
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
INTER₂(cons₂(x, l1), l2) -> MEM₂(x, l2)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 14 SCCs with 26 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

APP₂(cons₂(x, l1), l2) -> APP₂(l1, l2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = 2x₂ + 1

POL( APP₂(x₁, x₂) ) = x₁ + 3

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(#, 0₁(x)) -> GE₂(#, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

GE₂(#, 0₁(x)) -> GE₂(#, x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( GE₂(x₁, x₂) ) = 2x₁ + 3x₂

POL( 0₁(x₁) ) = x₁ + 2

POL( # ) = 3

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

GE₂(1₁(x), 1₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(1₁(x), 0₁(y)) -> GE₂(x, y)
GE₂(0₁(x), 1₁(y)) -> GE₂(y, x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( GE₂(x₁, x₂) ) = 3x₁ + 2x₂ + 2

POL( 0₁(x₁) ) = 2x₁ + 3

POL( 1₁(x₁) ) = 2x₁ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(0₁(x), #) -> EQ₂(x, #)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(0₁(x), #) -> EQ₂(x, #)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = 3x₁ + 3

POL( # ) = 2

POL( EQ₂(x₁, x₂) ) = 2x₁ + 3x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(#, 0₁(y)) -> EQ₂(#, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = x₁ + 2

POL( # ) = 3

POL( EQ₂(x₁, x₂) ) = 2x₁ + 3x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

EQ₂(1₁(x), 1₁(y)) -> EQ₂(x, y)
EQ₂(0₁(x), 0₁(y)) -> EQ₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = 2x₁ + 3

POL( EQ₂(x₁, x₂) ) = x₁ + 2x₂ + 3

POL( 1₁(x₁) ) = 2x₁ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MEM₂(x, cons₂(y, l)) -> MEM₂(x, l)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = 3x₁ + x₂ + 1

POL( MEM₂(x₁, x₂) ) = x₁ + 2x₂ + 3

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

INTER₂(l1, cons₂(x, l2)) -> IFINTER₄(mem₂(x, l1), x, l2, l1)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l3)
INTER₂(cons₂(x, l1), l2) -> IFINTER₄(mem₂(x, l2), x, l1, l2)
INTER₂(l1, app₂(l2, l3)) -> INTER₂(l1, l2)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l2, l3)
INTER₂(app₂(l1, l2), l3) -> INTER₂(l1, l3)

The remaining pairs can at least be oriented weakly.

IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( if₃(x₁, ..., x₃) ) = 3x₂ + 2

POL( # ) = 1

POL( eq₂(x₁, x₂) ) = max{0, 2x₂ - 1}

POL( 1₁(x₁) ) = max{0, x₁ - 3}

POL( mem₂(x₁, x₂) ) = max{0, 2x₁ - 3}

POL( nil ) = max{0, -3}

POL( cons₂(x₁, x₂) ) = 3x₁ + 2x₂ + 3

POL( true ) = 1

POL( false ) = max{0, -3}

POL( app₂(x₁, x₂) ) = 2x₁ + 2x₂ + 1

POL( 0₁(x₁) ) = max{0, 2x₁ - 1}

POL( IFINTER₄(x₁, ..., x₄) ) = 3x₂ + x₃ + x₄ + 1

POL( INTER₂(x₁, x₂) ) = x₁ + x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ DependencyGraphProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IFINTER₄(true, x, l1, l2) -> INTER₂(l1, l2)
IFINTER₄(false, x, l1, l2) -> INTER₂(l1, l2)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 2 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

-¹₂(1₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 1₁(y)) -> -¹₂(x, y)
-¹₂(0₁(x), 0₁(y)) -> -¹₂(x, y)
-¹₂(1₁(x), 1₁(y)) -> -¹₂(x, y)

The remaining pairs can at least be oriented weakly.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( -₂(x₁, x₂) ) = max{0, 2x₁ - 3}

POL( 0₁(x₁) ) = 3x₁ + 3

POL( 1₁(x₁) ) = 2x₁ + 2

POL( # ) = max{0, -3}

POL( -¹₂(x₁, x₂) ) = max{0, 2x₂ - 3}

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

-¹₂(0₁(x), 1₁(y)) -> -¹₂(-₂(x, y), 1₁(#))

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( -₂(x₁, x₂) ) = x₁

POL( 0₁(x₁) ) = 2x₁ + 2

POL( 1₁(x₁) ) = 2x₁ + 2

POL( # ) = max{0, -2}

POL( -¹₂(x₁, x₂) ) = max{0, 2x₁ - 1}

The following usable rules [14] were oriented:

-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(x, #) -> x
0₁(#) -> #
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
-₂(#, x) -> #

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

+¹₂(1₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(y, z)
+¹₂(1₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(0₁(x), 1₁(y)) -> +¹₂(x, y)
+¹₂(1₁(x), 1₁(y)) -> +¹₂(+₂(x, y), 1₁(#))

The remaining pairs can at least be oriented weakly.

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = x₁

POL( 1₁(x₁) ) = x₁ + 3

POL( +¹₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( +₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( # ) = 1

The following usable rules [14] were oriented:

+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(x, #) -> x
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(#, x) -> x
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
0₁(#) -> #
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)
+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

+¹₂(+₂(x, y), z) -> +¹₂(x, +₂(y, z))

The remaining pairs can at least be oriented weakly.

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = x₁

POL( 1₁(x₁) ) = max{0, x₁ - 2}

POL( +¹₂(x₁, x₂) ) = 2x₁

POL( +₂(x₁, x₂) ) = x₁ + 1

POL( # ) = max{0, -3}

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

+¹₂(0₁(x), 0₁(y)) -> +¹₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( +¹₂(x₁, x₂) ) = 3x₂ + 3

POL( 0₁(x₁) ) = x₁ + 3

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
SUM₁(cons₂(x, l)) -> SUM₁(l)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SUM₁(app₂(l1, l2)) -> SUM₁(l1)
SUM₁(app₂(l1, l2)) -> SUM₁(l2)
SUM₁(cons₂(x, l)) -> SUM₁(l)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = 2x₂ + 1

POL( app₂(x₁, x₂) ) = 3x₁ + 2x₂ + 3

POL( SUM₁(x₁) ) = x₁ + 2

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

*¹₂(1₁(x), y) -> *¹₂(x, y)
*¹₂(0₁(x), y) -> *¹₂(x, y)

The remaining pairs can at least be oriented weakly.

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( *¹₂(x₁, x₂) ) = 2x₁ + 2

POL( 0₁(x₁) ) = 2x₁ + 1

POL( 1₁(x₁) ) = x₁ + 2

POL( +₂(x₁, x₂) ) = 0

POL( # ) = 0

POL( *₂(x₁, x₂) ) = 2x₁ + 2x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

*¹₂(*₂(x, y), z) -> *¹₂(y, z)
*¹₂(*₂(x, y), z) -> *¹₂(x, *₂(y, z))

The remaining pairs can at least be oriented weakly.

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( *¹₂(x₁, x₂) ) = x₁ + 1

POL( 0₁(x₁) ) = 3x₁ + 3

POL( 1₁(x₁) ) = max{0, -3}

POL( +₂(x₁, x₂) ) = max{0, 3x₁ + 2x₂ - 2}

POL( # ) = 3

POL( *₂(x₁, x₂) ) = x₁ + 2x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

*¹₂(x, +₂(y, z)) -> *¹₂(x, z)
*¹₂(x, +₂(y, z)) -> *¹₂(x, y)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( *¹₂(x₁, x₂) ) = 3x₁ + x₂ + 3

POL( +₂(x₁, x₂) ) = 2x₁ + 2x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROD₁(app₂(l1, l2)) -> PROD₁(l2)
PROD₁(cons₂(x, l)) -> PROD₁(l)
PROD₁(app₂(l1, l2)) -> PROD₁(l1)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( cons₂(x₁, x₂) ) = 3x₁ + 2x₂ + 1

POL( PROD₁(x₁) ) = x₁ + 3

POL( app₂(x₁, x₂) ) = 2x₁ + 2x₂ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'₁(1₁(x)) -> LOG'₁(x)
LOG'₁(0₁(x)) -> LOG'₁(x)

The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

LOG'₁(1₁(x)) -> LOG'₁(x)
LOG'₁(0₁(x)) -> LOG'₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( 0₁(x₁) ) = 2x₁ + 2

POL( LOG'₁(x₁) ) = 2x₁

POL( 1₁(x₁) ) = 3x₁ + 1

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

0₁(#) -> #
+₂(x, #) -> x
+₂(#, x) -> x
+₂(0₁(x), 0₁(y)) -> 0₁(+₂(x, y))
+₂(0₁(x), 1₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 0₁(y)) -> 1₁(+₂(x, y))
+₂(1₁(x), 1₁(y)) -> 0₁(+₂(+₂(x, y), 1₁(#)))
+₂(+₂(x, y), z) -> +₂(x, +₂(y, z))
-₂(#, x) -> #
-₂(x, #) -> x
-₂(0₁(x), 0₁(y)) -> 0₁(-₂(x, y))
-₂(0₁(x), 1₁(y)) -> 1₁(-₂(-₂(x, y), 1₁(#)))
-₂(1₁(x), 0₁(y)) -> 1₁(-₂(x, y))
-₂(1₁(x), 1₁(y)) -> 0₁(-₂(x, y))
not₁(true) -> false
not₁(false) -> true
if₃(true, x, y) -> x
if₃(false, x, y) -> y
eq₂(#, #) -> true
eq₂(#, 1₁(y)) -> false
eq₂(1₁(x), #) -> false
eq₂(#, 0₁(y)) -> eq₂(#, y)
eq₂(0₁(x), #) -> eq₂(x, #)
eq₂(1₁(x), 1₁(y)) -> eq₂(x, y)
eq₂(0₁(x), 1₁(y)) -> false
eq₂(1₁(x), 0₁(y)) -> false
eq₂(0₁(x), 0₁(y)) -> eq₂(x, y)
ge₂(0₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(0₁(x), 1₁(y)) -> not₁(ge₂(y, x))
ge₂(1₁(x), 0₁(y)) -> ge₂(x, y)
ge₂(1₁(x), 1₁(y)) -> ge₂(x, y)
ge₂(x, #) -> true
ge₂(#, 0₁(x)) -> ge₂(#, x)
ge₂(#, 1₁(x)) -> false
log₁(x) -> -₂(log'₁(x), 1₁(#))
log'₁(#) -> #
log'₁(1₁(x)) -> +₂(log'₁(x), 1₁(#))
log'₁(0₁(x)) -> if₃(ge₂(x, 1₁(#)), +₂(log'₁(x), 1₁(#)), #)
*₂(#, x) -> #
*₂(0₁(x), y) -> 0₁(*₂(x, y))
*₂(1₁(x), y) -> +₂(0₁(*₂(x, y)), y)
*₂(*₂(x, y), z) -> *₂(x, *₂(y, z))
*₂(x, +₂(y, z)) -> +₂(*₂(x, y), *₂(x, z))
app₂(nil, l) -> l
app₂(cons₂(x, l1), l2) -> cons₂(x, app₂(l1, l2))
sum₁(nil) -> 0₁(#)
sum₁(cons₂(x, l)) -> +₂(x, sum₁(l))
sum₁(app₂(l1, l2)) -> +₂(sum₁(l1), sum₁(l2))
prod₁(nil) -> 1₁(#)
prod₁(cons₂(x, l)) -> *₂(x, prod₁(l))
prod₁(app₂(l1, l2)) -> *₂(prod₁(l1), prod₁(l2))
mem₂(x, nil) -> false
mem₂(x, cons₂(y, l)) -> if₃(eq₂(x, y), true, mem₂(x, l))
inter₂(x, nil) -> nil
inter₂(nil, x) -> nil
inter₂(app₂(l1, l2), l3) -> app₂(inter₂(l1, l3), inter₂(l2, l3))
inter₂(l1, app₂(l2, l3)) -> app₂(inter₂(l1, l2), inter₂(l1, l3))
inter₂(cons₂(x, l1), l2) -> ifinter₄(mem₂(x, l2), x, l1, l2)
inter₂(l1, cons₂(x, l2)) -> ifinter₄(mem₂(x, l1), x, l2, l1)
ifinter₄(true, x, l1, l2) -> cons₂(x, inter₂(l1, l2))
ifinter₄(false, x, l1, l2) -> inter₂(l1, l2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.